package com.ruoyi.system.service.impl;

import java.math.BigDecimal;
import java.math.RoundingMode;
import java.math.BigDecimal;
import java.util.ArrayList;
import java.util.HashMap;
import java.util.List;
import java.util.Map;

import com.ruoyi.common.utils.DateUtils;
import com.ruoyi.system.domain.QueryCondition;
import com.ruoyi.system.domain.Sumvo;
import com.ruoyi.system.domain.SysUserxq;
import com.ruoyi.system.mapper.SysUserxqMapper;
import com.ruoyi.system.mapper.UserScoreMapper;
import com.ruoyi.system.mapper.UserScoreMapper;
import com.ruoyi.system.service.ISysUserxqService;
import org.springframework.beans.factory.annotation.Autowired;
import org.springframework.stereotype.Service;
import com.github.pagehelper.PageHelper;
import com.github.pagehelper.PageInfo;


/**
 * 全员得分Service业务层处理
 * 
 * @author ruoyi
 * @date 2024-11-18
 */
@Service
public class SysUserxqServiceImpl implements ISysUserxqService
{

    @Autowired
    private SysUserxqMapper sysUserxqMapper;

    @Autowired
    private UserScoreMapper userScoreMapper;

    //查询报表
       @Override
    public List<Sumvo> selectUserList(Sumvo sumvo) {
    //取出 年月
        String assessDate = sumvo.getAssessDate();
        String[] split = assessDate.split("-");  //根据横杠分割
        String year = split[0];  //年
        String month = split[1]; //月
           List<Map> maps = sysUserxqMapper.selectGc(sumvo.getUserId(), month, year);
           List<Sumvo> ll  = new ArrayList<>();
           for (Map map : maps) {
               Sumvo so  =new Sumvo();
               so.setUserId((Long) map.get("user_id"));
               so.setNickName((String) map.get("nick_name"));
               so.setRoleId((Long) map.get("role_id"));
               //总分
               Double sum  = null ;
               //取出角色id
               Long roleId = (Long) map.get("role_id");
               //取出评价人的id
               Long userId = (Long) map.get("user_id");
                    //如果 等于 100  则计算各项分  和 总分     为基层
               if (roleId == 100L) {
                   Double ability = sysUserxqMapper.selectBygcjcsum(1L, sumvo.getUserId(), month, year, userId);
                   Double potential = sysUserxqMapper.selectBygcjcsum(7L, sumvo.getUserId(), month, year, userId);
                   sum=ability+potential;
                 so.setAbility(ability);
                 so.setPotential(potential);
                 so.setSum(sum);
               }
                    //如果 等于 102  则计算各项分  和 总分    为高层
               else if (roleId == 102L){
                   Double ability = sysUserxqMapper.selectBygcjcsum(1L, sumvo.getUserId(), month, year,userId);
                   Double potential = sysUserxqMapper.selectBygcjcsum(7L, sumvo.getUserId(), month, year, userId);
                   sum=ability+potential;
                 so.setAbility(ability);
                 so.setPotential(potential);
                 so.setSum(sum);
               }
               //如果 等于 102  则计算各项分  和 总分   为中层
               else if (roleId == 101L){
                   Double ability = sysUserxqMapper.selectBygcjcsum(1L, sumvo.getUserId(), month, year,userId);
                   Double potential = sysUserxqMapper.selectBygcjcsum(7L, sumvo.getUserId(), month, year, userId);
                   sum=ability+potential;
                   so.setAbility(ability);
                   so.setPotential(potential);
                   so.setSum(sum);
               }
                ll.add(so);
           }
           return ll;
    }

    // 查询某个人 给高层 20条 分别打了多少分
    @Override
    public List selectContent(Sumvo sumvo) {
        //取出 年月
        String assessDate = sumvo.getAssessDate();
        String[] split = assessDate.split("-");
        String year = split[0];
        String month = split[1];
        return sysUserxqMapper.selectAllcontent(sumvo.getUserId(),sumvo.getRaterNum(),month,year);
    }

    @Override
    public List selectByQuanzhong() {
        return sysUserxqMapper.selectDictLabel();
    }


    @Override
    public List<Map> selectSumByjc(Map map) {
         Integer parentId = (Integer) map.get("parentId");
         //能力测评
         Double score02=0.00;
         Double score03=0.00;
         Double score04=0.00;
         Double score05=0.00;
         Double score06=0.00;
         //素质测评
         Double score08=0.00;
         Double score09=0.00;
         Double score10=0.00;
         Double score11=0.00;
         Double score12=0.00;
         //先查出中高低层的权重比
         List<String> strings = sysUserxqMapper.selectDictLabel();
         Double d1 = Double.parseDouble(strings.get(0).replace("%",""));
         d1=d1/100;
         Double d2 = Double.parseDouble(strings.get(1).replace("%",""));
         d2=d2/100;
         Double d3 = Double.parseDouble(strings.get(2).replace("%",""));
         d3=d3/100;
         // 查询每个基层给领导的评分
         map.put("srrolId",100);
         List<Map> mape = sysUserxqMapper.selectSumByjc(map);
         //先遍历这个集合将这个集合的每一项的分数进行相加
         for (Map map1 : mape) {
             Integer category = (Integer) map1.get("category");//分类
             Double scores = (Double) map1.get("score");//分数
             if (parentId == 1) {
                 //先获取到这个分数的值
                 //能力测评
                 if (category==2){
                     score02+=scores;
                 } else if (category==3) {
                     score03+=scores;
                 } else if (category==4) {
                     score04+=scores;
                 } else if (category==5) {
                     score05+=scores;
                 } else if (category==6) {
                     score06+=scores;
                 }

             } else if (parentId==7) {
                 //素质评分
                 if (category==8){
                     score08+=scores;
                 } else if (category==9) {
                     score09+=scores;
                 } else if (category==10) {
                     score10+=scores;
                 } else if (category==11) {
                     score11+=scores;
                 } else if (category==12) {
                     score12+=scores;
                 }
             }
         }
         // 给这个领导评分的基层总人数
         Double l = sysUserxqMapper.selectByjcCount(map);
        if (l==0){
            l=1.00; //防止除0
        }
         // 每季度的每项平均分
// 能力测评的平均分
         BigDecimal bd02 = BigDecimal.valueOf(score02 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd03 = BigDecimal.valueOf(score03 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd04 = BigDecimal.valueOf(score04 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd05 = BigDecimal.valueOf(score05 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd06 = BigDecimal.valueOf(score06 / l*d3).setScale(2, RoundingMode.HALF_UP);
//基层给中层评分能力测评的分数占50%
         Double avg02 = bd02.doubleValue();
         Double avg03 = bd03.doubleValue();
         Double avg04 = bd04.doubleValue();
         Double avg05 = bd05.doubleValue();
         Double avg06 = bd06.doubleValue();
// 素质测评每个人的分数加起来的平均分
         BigDecimal bd08 = BigDecimal.valueOf(score08 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd09 = BigDecimal.valueOf(score09 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd10 = BigDecimal.valueOf(score10 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd11 = BigDecimal.valueOf(score11 / l*d3).setScale(2, RoundingMode.HALF_UP);
         BigDecimal bd12 = BigDecimal.valueOf(score12 / l*d3).setScale(2, RoundingMode.HALF_UP);
         //基层给中层评分素质测评的分数占60%
         Double avg08 = bd08.doubleValue();
         Double avg09 = bd09.doubleValue();
         Double avg10 = bd10.doubleValue();
         Double avg11 = bd11.doubleValue();
         Double avg12 = bd12.doubleValue();

         //查询中层给中层的评分
         map.put("srrolId",101);
         List<Map> mm = sysUserxqMapper.selectSumByjc(map);
         // 给这个领导评分的领导总人数
         Double m = sysUserxqMapper.selectByjcCount(map);
         if (m==0){
             m=1.00; //防止除0
         }
         for (Map map3 : mm) {
             Integer category = (Integer) map3.get("category");//分类
             Double scores = (Double) map3.get("score");//分数
             if (parentId==1){
                 //能力测评的分数      通过基层给中层打分占比50%+中层层给中层打分占比的30%
                 if (category==2){
                     BigDecimal a02 = BigDecimal.valueOf(avg02+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg02= a02.doubleValue();
                 } else if (category==3) {
                     BigDecimal a03 = BigDecimal.valueOf(avg03+(scores / m*d2)).setScale(2, RoundingMode.HALF_UP);
                     avg03= a03.doubleValue();
                 } else if (category==4) {
                     BigDecimal a04 = BigDecimal.valueOf(avg04+(scores / m*d2)).setScale(2, RoundingMode.HALF_UP);
                     avg04= a04.doubleValue();
                 } else if (category==5){
                     BigDecimal a05 = BigDecimal.valueOf(avg05+(scores / m*d2)).setScale(2, RoundingMode.HALF_UP);
                     avg05= a05.doubleValue();
                 } else if (category==6) {
                     BigDecimal a06 = BigDecimal.valueOf(avg06+(scores / m*d2)).setScale(2, RoundingMode.HALF_UP);
                     avg06= a06.doubleValue();
                 }
             } else if (parentId==7) {
                 //素质测评        通过基层给中层打分占比50%+中层层给中层打分占比的30%
                 if (category==8){
                     BigDecimal a08 = BigDecimal.valueOf(avg08+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg08= a08.doubleValue();
                 } else if (category==9) {
                     BigDecimal a09 = BigDecimal.valueOf(avg09+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg09= a09.doubleValue();
                 } else if (category==10) {
                     BigDecimal a10 = BigDecimal.valueOf(avg10+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg10= a10.doubleValue();
                 } else if (category==11) {
                     BigDecimal a11 = BigDecimal.valueOf(avg11+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg11= a11.doubleValue();
                 } else if (category==12) {
                     BigDecimal a12 = BigDecimal.valueOf(avg12+scores / m*d2).setScale(2, RoundingMode.HALF_UP);
                     avg12= a12.doubleValue();
                 }
             }
         }
         //查询领导给中层的评分
         map.put("srrolId",102);
         List<Map> mapp = sysUserxqMapper.selectSumByjc(map);
         // 给这个领导评分的领导总人数
         Double e = sysUserxqMapper.selectByjcCount(map);
         if (e==0){
             e=1.00; //防止除0
         }
         for (Map map3 : mapp) {
             Integer category = (Integer) map3.get("category");//分类
             Double scores = (Double) map3.get("score");//分数
             if (parentId==1){
                 //能力测评的分数      通过基层给中层打分占比50%+中层层给中层打分占比的30%+高层给中层打分占比的20%
                 if (category==2){
                     BigDecimal a02 = BigDecimal.valueOf(avg02+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg02= a02.doubleValue();
                 } else if (category==3) {
                     BigDecimal a03 = BigDecimal.valueOf(avg03+(scores / e*d1)).setScale(2, RoundingMode.HALF_UP);
                     avg03= a03.doubleValue();
                 } else if (category==4) {
                     BigDecimal a04 = BigDecimal.valueOf(avg04+(scores / e*d1)).setScale(2, RoundingMode.HALF_UP);
                     avg04= a04.doubleValue();
                 } else if (category==5){
                     BigDecimal a05 = BigDecimal.valueOf(avg05+(scores / e*d1)).setScale(2, RoundingMode.HALF_UP);
                     avg05= a05.doubleValue();
                 } else if (category==6) {
                     BigDecimal a06 = BigDecimal.valueOf(avg06+(scores / e*d1)).setScale(2, RoundingMode.HALF_UP);
                     avg06= a06.doubleValue();
                 }
             } else if (parentId==7) {
                 //素质测评         通过基层给中层打分占比60%+高层给中层打分占比的40%
                 if (category==8){
                     BigDecimal a08 = BigDecimal.valueOf(avg08+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg08= a08.doubleValue();
                 } else if (category==9) {
                     BigDecimal a09 = BigDecimal.valueOf(avg09+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg09= a09.doubleValue();
                 } else if (category==10) {
                     BigDecimal a10 = BigDecimal.valueOf(avg10+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg10= a10.doubleValue();
                 } else if (category==11) {
                     BigDecimal a11 = BigDecimal.valueOf(avg11+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg11= a11.doubleValue();
                 } else if (category==12) {
                     BigDecimal a12 = BigDecimal.valueOf(avg12+scores / e*d1).setScale(2, RoundingMode.HALF_UP);
                     avg12= a12.doubleValue();
                 }
             }
         }
         //再次遍历将一个季度数据加入
         List<Map> list1 = new ArrayList<>();
         //查询所有评价的详情
         List<Map> vose = userScoreMapper.selectUserScoreByUserId2(parentId);
         for (Map maps:vose) {
//            判断catgory为2时将平均数插进去然后得出对应分数的解析详情
             Integer category = (Integer) maps.get("category");//分类

//            能力测评，
             if (parentId==1){
                 if (category==2){
                     maps.put("score",avg02);
                 } else if (category==3) {
                     maps.put("score",avg03);
                 } else if (category==4) {
                     maps.put("score",avg04);
                 } else if (category==5) {
                     maps.put("score",avg05);
                 } else if (category==6) {
                     maps.put("score",avg06);
                 }
             }
//          素质测评
             if (parentId==7){
                 if (category==8) {
                     maps.put("score",avg08);
                 } else if (category==9) {
                     maps.put("score",avg09);
                 } else if (category==10) {
                     maps.put("score",avg10);
                 } else if (category==11) {
                     maps.put("score",avg11);
                 } else if (category==12) {
                     maps.put("score",avg12);
                 }
             }
             //将存入平均分的数据存入list中
             list1.add(maps);
         }
         //  定义最后一个集合将最终数据放进去
         List<Map> list2=new ArrayList<>();
         //判断分数的强弱
         for (Map map2:list1){
             Double score = (Double)map2.get("score");
             Integer grade = (Integer) map2.get("grade");//分类
             if (score>0&&score<10&&grade==3){
                 list2.add(map2);
             } else if (score>=10&&score<15&&grade==2) {
                 list2.add(map2);
             } else if (score>=15&&score<=20&&grade==1) {
                 list2.add(map2);
             }
         }
         return list2;
     }


    /**
 * 查询用户详细信息并进行分页
 *
 * @param queryCondition 查询条件，包含分页信息
 * @return 返回包含用户详细信息的分页结果
 */
@Override
public PageInfo<SysUserxq> selectUserDetails(QueryCondition queryCondition) {
    // 使用 PageHelper.startPage 方法进行分页设置，pageNum 是当前页，pageSize 是每页记录数
    PageHelper.startPage(queryCondition.getPageNum(), queryCondition.getPageSize());
    // 调用查询方法
    List<SysUserxq> userList = sysUserxqMapper.selectUserDetails(queryCondition);
    // 使用 PageInfo 包装查询结果，PageInfo 会自动包含分页信息
    return new PageInfo<>(userList);
}

/**
 * 查询所有部门信息并构建树形结构
 *
 * @return 返回构建好的树形结构的部门列表
 */
@Override
public List<SysUserxq> selectAllDept() {
    // 获取所有部门数据
    List<SysUserxq> deptList = sysUserxqMapper.selectAllDept();
    // 调用 buildDeptTree 方法构建树形结构并返回
    return buildDeptTree(deptList);
}

    /**
 * 根据部门列表构建树形结构
 * @param deptList 部门列表
 * @return 返回根节点列表，即树形结构的入口
 */
public List<SysUserxq> buildDeptTree(List<SysUserxq> deptList) {
    List<SysUserxq> rootNodes = new ArrayList<>();
    Map<Long, SysUserxq> deptMap = new HashMap<>();
    // 1. 构建部门映射关系
    for (SysUserxq dept : deptList) {
        deptMap.put(dept.getDeptId(), dept);  // 将 deptId 存入 deptMap
        // 如果 parentId 为 0，说明是根节点
        if (dept.getParentId() == 0) {
            rootNodes.add(dept);  // 父节点为0，视为根节点
        }
    }
    // 2. 建立父子关系并递归构建树形结构
    for (SysUserxq dept : deptList) {
        if (dept.getParentId() != 0) {
            SysUserxq parentDept = deptMap.get(dept.getParentId());
            if (parentDept != null) {
                // 把当前部门（子节点）添加到父节点的 children 中
                parentDept.getChildren().add(dept);
            }
        }
    }
    // 3. 返回根节点，即包含了完整树形结构的部门列表
    return rootNodes;
}

    /**
     * 查询所有用户及其所属部门岗位角色
     * @return
     */
    @Override
    public List<SysUserxq> selectAllUser() {
        return sysUserxqMapper.selectAllUser();
    }


}